﻿/*
LICENCE___________________________________________________________________
    Copyright (C) 2012 Reverdy Sylvain

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License along
    with this program; if not, write to the Free Software Foundation, Inc.,
    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
FIN LICENCE______________________________________________________________
*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using System.Windows.Controls;
using Merise_designer.Objets;
using System.Windows;

namespace Merise_designer.Methodes
{
   public class Entites
    {
        private List<CL_Entite> mEntites;
        private Donnees.CL_Entites dataEntite = new Donnees.CL_Entites();
        Methodes.ObjetsCommun controller;

        public Entites(Methodes.ObjetsCommun contructor, Grid grille)
        {
            this.controller = contructor;
            this.mEntites = new List<CL_Entite>();
        }

        public void load(Grid grille)
        {
            String jeu = "monjeu";
            System.Data.DataSet entites = new System.Data.DataSet();
            Donnees.CL_Entites entiteData = new Donnees.CL_Entites();

            entites = entiteData.selectAll(jeu);
            foreach (System.Data.DataRow theRow in entites.Tables[jeu].Rows)
            {
                //Convertion pour la position
                PointConverter pConverter = new PointConverter();
                Point position = new Point();
                string string1 = (string)theRow["POSITION_ENTITE"];
                position = (Point)pConverter.ConvertFromString(string1.Replace(";", ","));

                //Créé l'entité
                this.AddLoad(grille, (string)theRow["ID_ENTITE"], (string)theRow["NOM_ENTITE"], (string)theRow["CODE_ENTITE"], Convert.ToDouble(theRow["HAUT_ENTITE"]), Convert.ToDouble(theRow["LARG_ENTITE"]), position);
            }

        }
        public void Add(Grid grille, Point position)
        {
            this.mEntites.Add(new CL_Entite(controller, grille, CL_Variables.addNameAuto(), position));
            if (Mode.mode_save == Mode.MODE_SAVE_AUTO)
            {
                //Enregistrement dans la base
                dataEntite.add(mEntites.Last());
            }

        }
        public void AddLoad(Grid grille, string id, string nom, string codeNom, double hauteur, double largeur, Point position)
        {
            this.mEntites.Add(new CL_Entite(controller, grille, id, nom, codeNom, hauteur, largeur, position));
        }
        public void Del(Grid grille, string name)
        {
            foreach (CL_Entite ent in mEntites)
            {
                if (ent.Id == name)
                {
                    if (Mode.mode_save == Mode.MODE_SAVE_AUTO)
                    {
                        Donnees.CL_DictionnaireDeDonnees dataDico = new Donnees.CL_DictionnaireDeDonnees();
                        //Supprime de la base
                        //dataDico.deleteAllFromEntite(ent);
                        this.dataEntite.delete(ent.Id);
                    }

                    this.controller.getContructorDico().deleteAllFromEntite(ent);
                    ent.Supprimer(grille);
                    mEntites.Remove(ent);
                    return;
                }
            }
        }
        public void edit(string name)
        {
            foreach (CL_Entite ent in mEntites)
            {
                if (ent.Id == name)
                {
                    ent.edition(null, null);
                    return;
                }
            }
        }
        public int id(string name)
        {
            for (int i = 0; i < mEntites.Count; i++)
            {
                if (mEntites[i].Id == name)
                {
                    return i;
                }
            }
            return -1;
        }
        public double posLeft(string name)
        {
            foreach (CL_Entite ent in mEntites)
            {
                if (ent.Id == name)
                {
                    return ent.posLeft;
                }
            }
            return -1;
        }
        public double posTop(string name)
        {
            foreach (CL_Entite ent in mEntites)
            {
                if (ent.Id == name)
                {
                    return ent.posTop;
                }
            }
            return -1;
        }
        public void move(string name, Point from, Point to)
        {
            foreach (CL_Entite ent in mEntites)
            {
                if (ent.Id == name)
                {
                    ent.move(from, to);
                    return;
                }
            }
        }
        public void getFocus(Grid grille, string name)
        {
            foreach (CL_Entite ent in mEntites)
            {
                if (ent.Id == name)
                {
                    ent.getFocus(grille);
                    return;
                }
            }
        }
        public void lostFocus(Grid grille, string name)
        {
            foreach (CL_Entite ent in mEntites)
            {
                if (ent.Id == name)
                {
                    ent.lostFocus(grille);
                    return;
                }
            }
        }
        public CL_Entite getEntite(string name)
        {
            CL_Entite result = null;

            foreach (CL_Entite ent in mEntites)
            {
                if (ent.Id == name)
                {
                    result = ent;
                    return result;
                }
            }

            return result;
        }
        public List<CL_Entite> getAllEntites()
        {
            return this.mEntites;
        }
        public void movePoignees(string nameEntite, Point newCursor)
        {
            foreach (CL_Entite ent in mEntites)
            {
                if (ent.Id == nameEntite)
                {
                    ent.movePoignees(newCursor);
                }
            }
        }
        public int getIDpoignee(string nameEntite, Point cursor)
        {
            foreach (CL_Entite ent in mEntites)
            {
                if (ent.Id == nameEntite)
                {
                    return ent.getIDofPoigneeSelect(cursor);
                }
            }
            return -1;

        }
        public void afficheContenu(string monJeu)
        {
            foreach (CL_Entite ent in mEntites)
            {
                ent.afficheContenu(this.controller.getContructorDico().selectAllFromEntite(ent, monJeu));
            }
        }
        public void afficheContenuMLD(string monJeu, Tuple<Entites, Lignes, Associations> m_objets)
        {
            foreach (CL_Entite ent in mEntites)
            {
                afficheContenuMLD_of(ent, m_objets.Item2, m_objets.Item3);
            }
        }
        public List<CL_DictionnaireDeDonnees> afficheContenuMLD_of(CL_Entite entite,Lignes m_Lines,Associations m_Asso)
        {
            List<CL_DictionnaireDeDonnees> donneesBrut = new List<CL_DictionnaireDeDonnees>();

            List<CL_Line> myLines = m_Lines.getAllLines();
            //System.Data.DataSet donneesBrut = dataDico.selectAllFromVisualEntite(ent, monJeu);
            donneesBrut = this.controller.getContructorDico().selectAllFromEntite(entite, "monJeu");

            //Ajout des Clés étrangères pour cardinalité 0,1 ou 1,1 => reçoir la clé primaire des tables correspondantes
            foreach (CL_Line line in myLines)
            {
                //Pour chaque lignes connectés dont la cardinalité finit par "1"
                if (line.IsConnectedToEntite(entite) & line.Cardinalite.EndsWith("1"))
                {
                    //Récupère l'association concernée
                    CL_Association assoConnected = m_Asso.getAssociation(line.IdAssociation);
                    foreach (CL_Line lineConnected in myLines)
                    {
                        //Identifie les lignes connectées à l'entité
                        if (lineConnected.IsConnectedToAssociation(assoConnected) & lineConnected.IdEntite != entite.Id)
                        {
                            //récupère la table associée, sauf si cest l'entité en cours
                            CL_Entite entiteToExtractPK =this.getEntite(lineConnected.IdEntite);
                            //Récupère les clés primaires des tables associées aux lignes connectées
                            //récupère les données de la table
                            List<CL_DictionnaireDeDonnees> donneesKey = this.controller.getContructorDico().selectAllFromEntite(entiteToExtractPK, "monJeu");
                            //dataDico.selectAllFromVisualEntite(entiteToExtractPK, monJeu);
                            for (int i = 0; i < donneesKey.Count; i++)
                            {
                                //Récupère les clés primaires da la table et les place en clé étrangère
                                if (donneesKey[i].pk)
                                {
                                    String strO = this.controller.getContructorDico().getStringO(donneesKey[i].O);
                                    CL_DictionnaireDeDonnees d = new CL_DictionnaireDeDonnees(donneesKey[i].id, donneesKey[i].nom, donneesKey[i].code, donneesKey[i].idType, donneesKey[i].stringType, donneesKey[i].idAsso, donneesKey[i].idEntite, donneesKey[i].pk, donneesKey[i].O, strO, true);
                                    d.O = line.Cardinalite.StartsWith("1") ? true : false; //Champs obligatoire ou pas selon le début de la cardinalité
                                    d.stringO = this.controller.getContructorDico().getStringO(d.O);
                                    donneesBrut.Add(d);
                                }
                            }
                        }

                    }

                }
            }

            if(Mode.mode==Mode.MODE_MLD) entite.afficheContenu(donneesBrut);
            return donneesBrut;
        }
        public void saveUpdate(string name, Boolean force)
        {
            foreach (CL_Entite ent in mEntites)
            {
                if (ent.Id == name)
                {
                    if (Mode.mode_save == Mode.MODE_SAVE_AUTO || force)
                    {
                        dataEntite.update(ent);
                    }
                    return;
                }
            }
        }
        public CL_Entite getLast()
        {
            return this.mEntites.Last();
        }


    }
}
